home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 1996 March / Amiga-CD 1996 #3.iso / pd-software / mui_3.1 / developer / oberon / txt / muisimple.mod < prev    next >
Text File  |  1996-01-19  |  44KB  |  1,065 lines
  1. (*------------------------------------------
  2.  
  3.   :Module.      MuiSimple.mod
  4.   :Author.      Albert Weinert  [awn]
  5.   :Address.     Molkestr. 68, 50859 Köln, Germany
  6.   :EMail.       a.weinert@darkness.gun.de
  7.   :Phone.       +49-2234-480800
  8.   :Revision.    R.5
  9.   :Date.        19-Nov-1995
  10.   :Copyright.   Albert Weinert
  11.   :Language.    Oberon-2
  12.   :Translator.  AmigaOberon V3.20
  13.   :Contents.    Contains the object creation on a simple manner (but not so easy)
  14.   :Contents.    This Module is for "GenCodeOberon" which comes with MuiBuilder 2.0.
  15.   :Remarks.     *Don't mix MuiBasics.mod and MuiSimple.mod objects!!* Do that
  16.   :Remarks.     only if you want do dynamic object creation.
  17.   :Remarks.     Currently, there ist no Version for Oberon-2, 'cause V1.6 lacks
  18.   :Remakrs.     of a little feature.
  19.   :Bugs.        <Bekannte Fehler>
  20.   :Usage.       <Angaben zur Anwendung>
  21.   :History.     .1     [awn] 02-Jul-1994 : Erstellt
  22.   :History.     .2     [awn] 19-Aug-1994 : Do some work at the Module,
  23.   :History.     .3     [awn] 26-Sep-1994 : Requires now muimaster.library V8
  24.   :History.            Must changed some object creation to work with MakeObject()
  25.   :History.            because MuiBuilder 2.0 use features oft this function.
  26.   :History.     .4     [awn] 08-Nov-1994 : All e.STRPTR replaced with e.LSTRPTR,
  27.   :History.            know the Module needs the V40 Interfaces.
  28.   :History.     .5     [awn] 19-Nov-1995 : Updated to MUI 3.1 (V12)
  29.  
  30. --------------------------------------------*)
  31. MODULE MuiSimple;
  32.  
  33. IMPORT e := Exec,
  34.        I := Intuition,
  35.        m := Mui,
  36.        u := Utility,
  37.        y :=SYSTEM;
  38.  
  39. TYPE
  40. (* <*IF OberonA THEN*> $IF OberonA *)
  41.   Args      * = POINTER [2] TO ArgsDesc;
  42.   ArgsDesc  * = RECORD [2] END;
  43. (* <* ELSE *> $ELSE *)
  44.   Args      * = UNTRACED POINTER TO ArgsDesc;
  45.   ArgsDesc  * = STRUCT END;
  46. (* <*END*> $END *)
  47.  
  48.   HookDef * = PROCEDURE ( hook : u.HookPtr; object : m.Object; args : Args ):LONGINT;
  49.  
  50.   PROCEDURE MakeHook* ( VAR hook : u.Hook; entry: HookDef );
  51.     BEGIN
  52.       u.InitHook( y.ADR( hook ), y.VAL( u.HookFunc, entry ) );
  53.     END MakeHook;
  54.  
  55.   PROCEDURE SemaphoreObject*{"MuiSimple.SemaphoreObjectA"} ( tags{9}.. : u.Tag):m.Object;
  56.   PROCEDURE SemaphoreObjectA*( tags{9} : u.TagListPtr ):m.Object;
  57.     BEGIN (* SaveReg+ *)
  58.       RETURN m.NewObject( m.cSemaphore, u.more, tags );
  59.     END SemaphoreObjectA;
  60.  
  61.   PROCEDURE DataspaceObject*{"MuiSimple.DataspaceObjectA"} ( tags{9}.. : u.Tag):m.Object;
  62.   PROCEDURE DataspaceObjectA*( tags{9} : u.TagListPtr ):m.Object;
  63.     BEGIN (* SaveReg+ *)
  64.       RETURN m.NewObject( m.cDataspace, u.more, tags );
  65.     END DataspaceObjectA;
  66.  
  67.   PROCEDURE ConfigdataObject*{"MuiSimple.ConfigdataObjectA"} ( tags{9}.. : u.Tag):m.Object;
  68.   PROCEDURE ConfigdataObjectA*( tags{9} : u.TagListPtr ):m.Object;
  69.     BEGIN (* SaveReg+ *)
  70.       RETURN m.NewObject( m.cConfigdata, u.more, tags );
  71.     END ConfigdataObjectA;
  72.  
  73.   PROCEDURE FamilyObject*{"MuiSimple.FamilyObjectA"} ( tags{9}.. : u.Tag):m.Object;
  74.   PROCEDURE FamilyObjectA*( tags{9} : u.TagListPtr ):m.Object;
  75.     BEGIN (* SaveReg+ *)
  76.       RETURN m.NewObject( m.cFamily, u.more, tags );
  77.     END FamilyObjectA;
  78.  
  79.   PROCEDURE MenustripObject*{"MuiSimple.MenustripObjectA"} ( tags{9}.. : u.Tag):m.Object;
  80.   PROCEDURE MenustripObjectA*( tags{9} : u.TagListPtr ):m.Object;
  81.     BEGIN (* SaveReg+ *)
  82.       RETURN m.NewObject( m.cMenustrip, u.more, tags );
  83.     END MenustripObjectA;
  84.  
  85.   PROCEDURE MenuObject*{"MuiSimple.MenuObjectA"} ( tags{9}.. : u.Tag):m.Object;
  86.   PROCEDURE MenuObjectA*( tags{9} : u.TagListPtr ):m.Object;
  87.     BEGIN (* SaveReg+ *)
  88.       RETURN m.NewObject( m.cMenu, u.more, tags );
  89.     END MenuObjectA;
  90.  
  91.   PROCEDURE MenuTObject*{"MuiSimple.MenuTObjectA"} ( name {8}: ARRAY OF CHAR; tags{9}.. : u.Tag):m.Object;
  92.   PROCEDURE MenuTObjectA*( name {8}: e.LSTRPTR; tags{9} : u.TagListPtr ):m.Object;
  93.     BEGIN (* SaveReg+ *)
  94.       RETURN m.NewObject( m.cMenu, m.aMenuTitle, name, u.more, tags );
  95.     END MenuTObjectA;
  96.  
  97.   PROCEDURE MenuitemObject*{"MuiSimple.MenuitemObjectA"} ( tags{9}.. : u.Tag):m.Object;
  98.   PROCEDURE MenuitemObjectA*( tags{9} : u.TagListPtr ):m.Object;
  99.     BEGIN (* SaveReg+ *)
  100.       RETURN m.NewObject( m.cMenuitem, u.more, tags );
  101.     END MenuitemObjectA;
  102.  
  103.   PROCEDURE WindowObject*{"MuiSimple.WindowObjectA"} ( tags{9}.. : u.Tag):m.Object;
  104.   PROCEDURE WindowObjectA*( tags{9} : u.TagListPtr ):m.Object;
  105.     BEGIN (* SaveReg+ *)
  106.       RETURN m.NewObject( m.cWindow, u.more, tags );
  107.     END WindowObjectA;
  108.  
  109.   PROCEDURE ImageObject*{"MuiSimple.ImageObjectA"} ( tags{9}.. : u.Tag): m.Object;
  110.   PROCEDURE ImageObjectA*( tags{9} : u.TagListPtr ): m.Object;
  111.     BEGIN (* SaveReg+ *)
  112.       RETURN m.NewObject( m.cImage, u.more, tags );
  113.     END ImageObjectA;
  114.  
  115.   PROCEDURE BitmapObject*{"MuiSimple.BitmapObjectA"} ( tags{9}.. : u.Tag):m.Object;
  116.   PROCEDURE BitmapObjectA*( tags{9} : u.TagListPtr ):m.Object;
  117.     BEGIN (* SaveReg+ *)
  118.       RETURN m.NewObject( m.cBitmap, u.more, tags );
  119.     END BitmapObjectA;
  120.  
  121.   PROCEDURE BodychunkObject*{"MuiSimple.BodychunkObjectA"} ( tags{9}.. : u.Tag):m.Object;
  122.   PROCEDURE BodychunkObjectA*( tags{9} : u.TagListPtr ):m.Object;
  123.     BEGIN (* SaveReg+ *)
  124.       RETURN m.NewObject( m.cBodychunk, u.more, tags );
  125.     END BodychunkObjectA;
  126.  
  127.   PROCEDURE NotifyObject*{"MuiSimple.NotifyObjectA"} ( tags{9}.. : u.Tag): m.Object;
  128.   PROCEDURE NotifyObjectA*( tags{9} : u.TagListPtr ): m.Object;
  129.     BEGIN (* SaveReg+ *)
  130.       RETURN m.NewObject( m.cNotify, u.more, tags );
  131.     END NotifyObjectA;
  132.  
  133.   PROCEDURE ApplicationObject*{"MuiSimple.ApplicationObjectA"} ( tags{9}.. : u.Tag): m.Object;
  134.   PROCEDURE ApplicationObjectA*( tags{9} : u.TagListPtr ): m.Object;
  135.     BEGIN (* SaveReg+ *)
  136.       RETURN m.NewObject( m.cApplication, u.more, tags );
  137.     END ApplicationObjectA;
  138.  
  139.   PROCEDURE TextObject*{"MuiSimple.TextObjectA"} ( tags{9}.. : u.Tag): m.Object;
  140.   PROCEDURE TextObjectA*( tags{9} : u.TagListPtr ): m.Object;
  141.     BEGIN (* SaveReg+ *)
  142.       RETURN m.NewObject( m.cText, u.more, tags );
  143.     END TextObjectA;
  144.  
  145.   PROCEDURE RectangleObject*{"MuiSimple.RectangleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  146.   PROCEDURE RectangleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  147.     BEGIN (* SaveReg+ *)
  148.       RETURN m.NewObject( m.cRectangle, u.more, tags );
  149.     END RectangleObjectA;
  150.  
  151.   PROCEDURE ListObject*{"MuiSimple.ListObjectA"} ( tags{9}.. : u.Tag): m.Object;
  152.   PROCEDURE ListObjectA*( tags{9} : u.TagListPtr ): m.Object;
  153.     BEGIN (* SaveReg+ *)
  154.       RETURN m.NewObject( m.cList, u.more, tags );
  155.     END ListObjectA;
  156.  
  157.   PROCEDURE PropObject*{"MuiSimple.PropObjectA"} ( tags{9}.. : u.Tag): m.Object;
  158.   PROCEDURE PropObjectA*( tags{9} : u.TagListPtr ): m.Object;
  159.     BEGIN (* SaveReg+ *)
  160.       RETURN m.NewObject( m.cProp, u.more, tags );
  161.     END PropObjectA;
  162.  
  163.   PROCEDURE StringObject*{"MuiSimple.StringObjectA"} ( tags{9}.. : u.Tag): m.Object;
  164.   PROCEDURE StringObjectA*( tags{9} : u.TagListPtr ): m.Object;
  165.     BEGIN (* SaveReg+ *)
  166.       RETURN m.NewObject( m.cString, u.more, tags );
  167.     END StringObjectA;
  168.  
  169.   PROCEDURE ScrollbarObject*{"MuiSimple.ScrollbarObjectA"} ( tags{9}.. : u.Tag): m.Object;
  170.   PROCEDURE ScrollbarObjectA*( tags{9} : u.TagListPtr ): m.Object;
  171.     BEGIN (* SaveReg+ *)
  172.       RETURN m.NewObject( m.cScrollbar, u.more, tags );
  173.     END ScrollbarObjectA;
  174.  
  175.   PROCEDURE ListviewObject*{"MuiSimple.ListviewObjectA"} ( tags{9}.. : u.Tag): m.Object;
  176.   PROCEDURE ListviewObjectA*( tags{9} : u.TagListPtr ): m.Object;
  177.     BEGIN (* SaveReg+ *)
  178.       RETURN m.NewObject( m.cListview, u.more, tags );
  179.     END ListviewObjectA;
  180.  
  181.   PROCEDURE RadioObject*{"MuiSimple.RadioObjectA"} ( tags{9}.. : u.Tag): m.Object;
  182.   PROCEDURE RadioObjectA*( tags{9} : u.TagListPtr ): m.Object;
  183.     BEGIN (* SaveReg+ *)
  184.       RETURN m.NewObject( m.cRadio, u.more, tags );
  185.     END RadioObjectA;
  186.  
  187.   PROCEDURE VolumelistObject*{"MuiSimple.VolumelistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  188.   PROCEDURE VolumelistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  189.     BEGIN (* SaveReg+ *)
  190.       RETURN m.NewObject( m.cVolumelist, u.more, tags );
  191.     END VolumelistObjectA;
  192.  
  193.   PROCEDURE FloattextObject*{"MuiSimple.FloattextObjectA"} ( tags{9}.. : u.Tag): m.Object;
  194.   PROCEDURE FloattextObjectA*( tags{9} : u.TagListPtr ): m.Object;
  195.     BEGIN (* SaveReg+ *)
  196.       RETURN m.NewObject( m.cFloattext, u.more, tags );
  197.     END FloattextObjectA;
  198.  
  199.   PROCEDURE DirlistObject*{"MuiSimple.DirlistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  200.   PROCEDURE DirlistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  201.     BEGIN (* SaveReg+ *)
  202.       RETURN m.NewObject( m.cDirlist, u.more, tags );
  203.     END DirlistObjectA;
  204.  
  205.   PROCEDURE CycleObject*{"MuiSimple.CycleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  206.   PROCEDURE CycleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  207.     BEGIN (* SaveReg+ *)
  208.       RETURN m.NewObject( m.cCycle, u.more, tags );
  209.     END CycleObjectA;
  210.  
  211.   PROCEDURE GaugeObject*{"MuiSimple.GaugeObjectA"} ( tags{9}.. : u.Tag): m.Object;
  212.   PROCEDURE GaugeObjectA*( tags{9} : u.TagListPtr ): m.Object;
  213.     BEGIN (* SaveReg+ *)
  214.       RETURN m.NewObject( m.cGauge, u.more, tags );
  215.     END GaugeObjectA;
  216.  
  217.   PROCEDURE NumericObject*{"MuiSimple.NumericObjectA"} ( tags{9}.. : u.Tag):m.Object;
  218.   PROCEDURE NumericObjectA*( tags{9} : u.TagListPtr ):m.Object;
  219.     BEGIN (* SaveReg+ *)
  220.       RETURN m.NewObject( m.cNumeric, u.more, tags );
  221.     END NumericObjectA;
  222.  
  223.   PROCEDURE SliderObject*{"MuiSimple.SliderObjectA"} ( tags{9}.. : u.Tag): m.Object;
  224.   PROCEDURE SliderObjectA*( tags{9} : u.TagListPtr ): m.Object;
  225.     BEGIN (* SaveReg+ *)
  226.       RETURN m.NewObject( m.cSlider, u.more, tags );
  227.     END SliderObjectA;
  228.  
  229.   PROCEDURE NumericbutonObject*{"MuiSimple.NumericbuttonObjectA"} ( tags{9}.. : u.Tag):m.Object;
  230.   PROCEDURE NumericbuttonObjectA*( tags{9} : u.TagListPtr ):m.Object;
  231.     BEGIN (* SaveReg+ *)
  232.       RETURN m.NewObject( m.cNumericbutton, u.more, tags );
  233.     END NumericbuttonObjectA;
  234.  
  235.   PROCEDURE KnobObject*{"MuiSimple.KnobObjectA"} ( tags{9}.. : u.Tag):m.Object;
  236.   PROCEDURE KnobObjectA*( tags{9} : u.TagListPtr ):m.Object;
  237.     BEGIN (* SaveReg+ *)
  238.       RETURN m.NewObject( m.cKnob, u.more, tags );
  239.     END KnobObjectA;
  240.  
  241.   PROCEDURE LevelmeterObject*{"MuiSimple.LevelmeterObjectA"} ( tags{9}.. : u.Tag):m.Object;
  242.   PROCEDURE LevelmeterObjectA*( tags{9} : u.TagListPtr ):m.Object;
  243.     BEGIN (* SaveReg+ *)
  244.       RETURN m.NewObject( m.cLevelmeter, u.more, tags );
  245.     END LevelmeterObjectA;
  246.  
  247.   PROCEDURE ScaleObject*{"MuiSimple.ScaleObjectA"} ( tags{9}.. : u.Tag): m.Object;
  248.   PROCEDURE ScaleObjectA*( tags{9} : u.TagListPtr ): m.Object;
  249.     BEGIN (* SaveReg+ *)
  250.       RETURN m.NewObject( m.cScale, u.more, tags );
  251.     END ScaleObjectA;
  252.  
  253.   PROCEDURE BoopsiObject*{"MuiSimple.BoopsiObjectA"} ( tags{9}.. : u.Tag): m.Object;
  254.   PROCEDURE BoopsiObjectA*( tags{9} : u.TagListPtr ): m.Object;
  255.     BEGIN (* SaveReg+ *)
  256.       RETURN m.NewObject( m.cBoopsi, u.more, tags );
  257.     END BoopsiObjectA;
  258.  
  259.   PROCEDURE ColorfieldObject*{"MuiSimple.ColorfieldObjectA"} ( tags{9}.. : u.Tag): m.Object;
  260.   PROCEDURE ColorfieldObjectA*( tags{9} : u.TagListPtr ): m.Object;
  261.     BEGIN (* SaveReg+ *)
  262.       RETURN m.NewObject( m.cColorfield, u.more, tags );
  263.     END ColorfieldObjectA;
  264.  
  265.   PROCEDURE ColoradjustObject*{"MuiSimple.ColoradjustObjectA"} ( tags{9}.. : u.Tag): m.Object;
  266.   PROCEDURE ColoradjustObjectA*( tags{9} : u.TagListPtr ): m.Object;
  267.     BEGIN (* SaveReg+ *)
  268.       RETURN m.NewObject( m.cColoradjust, u.more, tags );
  269.     END ColoradjustObjectA;
  270.  
  271.   PROCEDURE PenadjustObject*{"MuiSimple.PenadjustObjectA"} ( tags{9}.. : u.Tag):m.Object;
  272.   PROCEDURE PenadjustObjectA*( tags{9} : u.TagListPtr ):m.Object;
  273.     BEGIN (* SaveReg+ *)
  274.       RETURN m.NewObject( m.cPenadjust, u.more, tags );
  275.     END PenadjustObjectA;
  276.  
  277.  PROCEDURE PaletteObject*{"MuiSimple.PaletteObjectA"} ( tags{9}.. : u.Tag): m.Object;
  278.   PROCEDURE PaletteObjectA*( tags{9} : u.TagListPtr ): m.Object;
  279.     BEGIN (* SaveReg+ *)
  280.       RETURN m.NewObject( m.cPalette, u.more, tags );
  281.     END PaletteObjectA;
  282.  
  283.   PROCEDURE GroupObject*{"MuiSimple.GroupObjectA"} ( tags{9}.. : u.Tag): m.Object;
  284.   PROCEDURE GroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  285.     BEGIN (* SaveReg+ *)
  286.       RETURN m.NewObject( m.cGroup, u.more, tags );
  287.     END GroupObjectA;
  288.  
  289.   PROCEDURE RegisterObject*{"MuiSimple.RegisterObjectA"} ( tags{9}.. : u.Tag): m.Object;
  290.   PROCEDURE RegisterObjectA*( tags{9} : u.TagListPtr ): m.Object;
  291.     BEGIN (* SaveReg+ *)
  292.       RETURN m.NewObject( m.cRegister, u.more, tags );
  293.     END RegisterObjectA;
  294.  
  295.   PROCEDURE VirtgroupObject*{"MuiSimple.VirtgroupObjectA"} ( tags{9}.. : u.Tag): m.Object;
  296.   PROCEDURE VirtgroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  297.     BEGIN (* SaveReg+ *)
  298.       RETURN m.NewObject( m.cVirtgroup, u.more, tags );
  299.     END VirtgroupObjectA;
  300.  
  301.   PROCEDURE ScrollgroupObject*{"MuiSimple.ScrollgroupObjectA"} ( tags{9}.. : u.Tag ): m.Object;
  302.   PROCEDURE ScrollgroupObjectA*( tags{9} : u.TagListPtr ): m.Object;
  303.     BEGIN (* SaveReg+ *)
  304.       RETURN m.NewObject( m.cScrollgroup, u.more, tags );
  305.     END ScrollgroupObjectA;
  306.  
  307.   PROCEDURE PopstringObject*{"MuiSimple.PopstringObjectA"} ( tags{9}.. : u.Tag): m.Object;
  308.   PROCEDURE PopstringObjectA*( tags{9} : u.TagListPtr ): m.Object;
  309.     BEGIN (* SaveReg+ *)
  310.       RETURN m.NewObject( m.cPopstring, u.more, tags );
  311.     END PopstringObjectA;
  312.  
  313.   PROCEDURE PopobjectObject*{"MuiSimple.PopobjectObjectA"} ( tags{9}.. : u.Tag): m.Object;
  314.   PROCEDURE PopobjectObjectA*( tags{9} : u.TagListPtr ): m.Object;
  315.     BEGIN (* SaveReg+ *)
  316.       RETURN m.NewObject( m.cPopobject, u.more, tags );
  317.     END PopobjectObjectA;
  318.  
  319.   PROCEDURE PoplistObject*{"MuiSimple.PoplistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  320.   PROCEDURE PoplistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  321.     BEGIN (* SaveReg+ *)
  322.       RETURN m.NewObject( m.cPoplist, u.more, tags );
  323.     END PoplistObjectA;
  324.  
  325.   PROCEDURE PopaslObject*{"MuiSimple.PopaslObjectA"} ( tags{9}.. : u.Tag): m.Object;
  326.   PROCEDURE PopaslObjectA*( tags{9} : u.TagListPtr ): m.Object;
  327.     BEGIN (* SaveReg+ *)
  328.       RETURN m.NewObject( m.cPopasl, u.more, tags );
  329.     END PopaslObjectA;
  330.  
  331.   PROCEDURE PoppenObject*{"MuiSimple.PoppenObjectA"} ( tags{9}.. : u.Tag):m.Object;
  332.   PROCEDURE PoppenObjectA*( tags{9} : u.TagListPtr ):m.Object;
  333.     BEGIN (* SaveReg+ *)
  334.       RETURN m.NewObject( m.cPoppen, u.more, tags );
  335.     END PoppenObjectA;
  336.  
  337.   PROCEDURE AboutmuiObject*{"MuiSimple.AboutmuiObjectA"} ( tags{9}.. : u.Tag):m.Object;
  338.   PROCEDURE AboutmuiObjectA*( tags{9} : u.TagListPtr ):m.Object;
  339.     BEGIN (* SaveReg+ *)
  340.       RETURN m.NewObject( m.cAboutmui, u.more, tags );
  341.     END AboutmuiObjectA;
  342.  
  343.   PROCEDURE ScrmodelistObject*{"MuiSimple.ScrmodelistObjectA"} ( tags{9}.. : u.Tag): m.Object;
  344.   PROCEDURE ScrmodelistObjectA*( tags{9} : u.TagListPtr ): m.Object;
  345.     BEGIN (* SaveReg+ *)
  346.       RETURN m.NewObject( m.cScrmodelist, u.more, tags );
  347.     END ScrmodelistObjectA;
  348.  
  349.   PROCEDURE VGroup*{"MuiSimple.VGroupA"}( tags{9}.. : u.Tag ): m.Object;
  350.   PROCEDURE VGroupA*( tags{9} : u.TagListPtr ): m.Object;
  351.     BEGIN (* SaveReg+ *)
  352.       RETURN m.NewObject( m.cGroup, u.more, tags );
  353.     END VGroupA;
  354.  
  355.   PROCEDURE HGroup*{"MuiSimple.HGroupA"}( tags{9}.. : u.Tag ): m.Object;
  356.   PROCEDURE HGroupA*( tags{9} : u.TagListPtr ): m.Object;
  357.     BEGIN (* SaveReg+ *)
  358.       RETURN m.NewObject( m.cGroup, m.aGroupHoriz, e.true, u.more, tags );
  359.     END HGroupA;
  360.  
  361.   PROCEDURE ColGroup*{"MuiSimple.ColGroupA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag );
  362.   PROCEDURE ColGroupA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  363.     BEGIN (* SaveReg+ *)
  364.       RETURN m.NewObject( m.cGroup, m.aGroupColumns, cols, u.more, tags );
  365.     END ColGroupA;
  366.  
  367.   PROCEDURE RowGroup*{"MuiSimple.RowGroupA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  ): m.Object;
  368.   PROCEDURE RowGroupA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  369.     BEGIN (* SaveReg+ *)
  370.       RETURN m.NewObject( m.cGroup, m.aGroupRows, rows, u.more, tags );
  371.     END RowGroupA;
  372.  
  373.   PROCEDURE PageGroup*{"MuiSimple.PageGroupA"}( tags{9}.. : u.Tag ): m.Object;
  374.   PROCEDURE PageGroupA*( tags{9} : u.TagListPtr ): m.Object;
  375.     BEGIN (* SaveReg+ *)
  376.       RETURN m.NewObject( m.cGroup, m.aGroupPageMode, e.true, u.more, tags );
  377.     END PageGroupA;
  378.  
  379.   PROCEDURE VGroupV*{"MuiSimple.VGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  380.   PROCEDURE VGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  381.     BEGIN (* SaveReg+ *)
  382.       RETURN m.NewObject( m.cVirtgroup, u.more, tags );
  383.     END VGroupVA;
  384.  
  385.   PROCEDURE HGroupV*{"MuiSimple.HGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  386.   PROCEDURE HGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  387.     BEGIN (* SaveReg+ *)
  388.       RETURN m.NewObject( m.cVirtgroup, m.aGroupHoriz, e.true, u.more, tags );
  389.     END HGroupVA;
  390.  
  391.   PROCEDURE ColGroupV*{"MuiSimple.ColGroupVA"} ( cols{3} : LONGINT; tags{9}.. : u.Tag ): m.Object;
  392.   PROCEDURE ColGroupVA*( cols{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  393.     BEGIN (* SaveReg+ *)
  394.       RETURN m.NewObject( m.cVirtgroup, m.aGroupColumns, cols, u.more, tags );
  395.     END ColGroupVA;
  396.  
  397.   PROCEDURE RowGroupV*{"MuiSimple.RowGroupVA"}( rows{3} : LONGINT; tags{9}.. : u.Tag  ): m.Object;
  398.   PROCEDURE RowGroupVA*( rows{3} : LONGINT; tags{9} : u.TagListPtr  ): m.Object;
  399.     BEGIN (* SaveReg+ *)
  400.       RETURN m.NewObject( m.cVirtgroup, m.aGroupRows, rows, u.more, tags);
  401.     END RowGroupVA;
  402.  
  403.   PROCEDURE PageGroupV*{"MuiSimple.PageGroupVA"}( tags{9}.. : u.Tag ): m.Object;
  404.   PROCEDURE PageGroupVA*( tags{9} : u.TagListPtr ): m.Object;
  405.     BEGIN (* SaveReg+ *)
  406.       RETURN m.NewObject( m.cVirtgroup, m.aGroupPageMode, e.true, u.more, tags );
  407.     END PageGroupVA;
  408.  
  409.   PROCEDURE RegisterGroup*{"MuiSimple.RegisterGroupA"}( t{8} : e.APTR; tags{9}.. : u.Tag ): m.Object;
  410.   PROCEDURE RegisterGroupA*( t{8} : e.APTR; tags{9} : u.TagListPtr ): m.Object;
  411.     BEGIN (* SaveReg+ *)
  412.       RETURN m.NewObject( m.cRegister, m.aRegisterTitles, t, u.more, tags );
  413.     END RegisterGroupA;
  414.  
  415.  
  416. (***************************************************************************
  417. **
  418. ** Baring Procedures
  419. ** ------------------
  420. **
  421. ***************************************************************************)
  422.  
  423.   PROCEDURE HBar*(): m.Object;
  424.     BEGIN (* SaveReg+ *)
  425.       RETURN m.NewObject( m.cRectangle,
  426.               m.aRectangleHBar, e.true,
  427.               m.aFixHeight, 2,
  428.               u.done ) ;
  429.     END HBar;
  430.  
  431.   PROCEDURE VBar*(): m.Object;
  432.     BEGIN (* SaveReg+ *)
  433.       RETURN m.NewObject( m.cRectangle,
  434.               m.aRectangleVBar, e.true,
  435.               m.aFixWidth, 2,
  436.               u.done );
  437.     END VBar;
  438.  
  439. (***************************************************************************
  440. **
  441. ** Spacing Procedures
  442. ** ------------------
  443. **
  444. ***************************************************************************)
  445.  
  446.   PROCEDURE HVSpace*(): m.Object;
  447.     BEGIN (* SaveReg+ *)
  448.       RETURN m.NewObject( m.cRectangle, u.done );
  449.     END HVSpace;
  450.  
  451. (*
  452.  *  PROCEDURE GroupSpacing*( x: LONGINT );
  453.  *  (*  *)
  454.  *    BEGIN (* SaveReg+ *)
  455.  *      TagItem( m.aGroupSpacing, x );
  456.  *    END GroupSpacing;
  457.  *)
  458.  
  459.   PROCEDURE HSpace*( x : LONGINT ): m.Object;
  460.     BEGIN (* SaveReg+ *)
  461.       RETURN m.MakeObject( m.oHSpace, x );
  462.     END HSpace;
  463.  
  464.   PROCEDURE VSpace*( x : LONGINT ): m.Object;
  465.     BEGIN (* SaveReg+ *)
  466.       RETURN m.MakeObject( m.oVSpace, x );
  467.     END VSpace;
  468.  
  469.  
  470.   PROCEDURE HCenterObject*( obj : m.Object ): m.Object;
  471.     VAR spL, spR : m.Object;
  472.     BEGIN (* SaveReg+ *)
  473.       spL := HSpace( 0 );
  474.       spR := HSpace( 0 );
  475.       RETURN HGroup( m.aGroupSpacing, 0,
  476.              m.aGroupChild, spL,
  477.              m.aGroupChild, obj,
  478.              m.aGroupChild, spR,
  479.              u.end );
  480.     END HCenterObject;
  481.  
  482.   PROCEDURE VCenterObject*( obj : m.Object ): m.Object;
  483.     VAR spO, spU : m.Object;
  484.     BEGIN (* SaveReg+ *)
  485.       spO := VSpace( 0 );
  486.       spU := VSpace( 0 );
  487.       RETURN VGroup( m.aGroupSpacing,0,
  488.              m.aGroupChild, spO,
  489.              m.aGroupChild, obj,
  490.              m.aGroupChild, spU,
  491.              u.end );
  492.     END VCenterObject;
  493.  
  494.  
  495. (*
  496.  *  PROCEDURE InnerSpacing*( h, v : LONGINT );
  497.  *  (*  *)
  498.  *    BEGIN (* SaveReg+ *)
  499.  *      Tags( m.aInnerLeft   , h,
  500.  *            m.aInnerRight  , h,
  501.  *            m.aInnerTop    , v,
  502.  *            m.aInnerBottom , v,
  503.  *            u.end );
  504.  *    END InnerSpacing;
  505.  *)
  506.  
  507.  
  508. (***************************************************************************
  509. **
  510. ** String-Object
  511. ** -------------
  512. **
  513. ** The following procedure creates a simple string gadget.
  514. **
  515. ***************************************************************************)
  516.  
  517.   PROCEDURE String * {"MuiSimple.StringA"} ( contents{8} : ARRAY OF CHAR; maxlen{3} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  518.   PROCEDURE StringA*( contents{8} : e.LSTRPTR; maxlen{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  519.     BEGIN (* SaveReg+ *)
  520.       RETURN StringObject( m.aFrame, m.vFrameString,
  521.                m.aStringMaxLen, maxlen,
  522.                m.aStringContents, contents,
  523.                u.more, tags );
  524.     END StringA;
  525.  
  526.   PROCEDURE KeyString * {"MuiSimple.KeyStringA"} ( contents{8} : ARRAY OF CHAR; maxlen{3} : LONGINT; controlchar{4}: CHAR; tags{9}.. : u.Tag ):m.Object;
  527.   PROCEDURE KeyStringA*( contents{8} : e.LSTRPTR; maxlen{3} : LONGINT; controlchar{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  528.     BEGIN (* SaveReg+ *)
  529.       RETURN String( contents^, maxlen, m.aControlChar, controlchar, u.more, tags );
  530.     END KeyStringA;
  531.  
  532. (***************************************************************************
  533. **
  534. ** Integer-Object
  535. ** --------------
  536. **
  537. ** The following procedure creates a simple integer string gadget.
  538. **
  539. ***************************************************************************)
  540.  
  541.   PROCEDURE Integer * {"MuiSimple.IntegerA"} ( contents{0} : LONGINT; maxlen{1} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  542.   PROCEDURE IntegerA*( contents{0} : LONGINT; maxlen{1} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  543.     BEGIN (* SaveReg+ *)
  544.       RETURN StringObject( m.aFrame, m.vFrameString,
  545.                m.aStringMaxLen, maxlen,
  546.                m.aStringInteger, contents,
  547.                m.aStringAccept, y.ADR( "0123456789" ),
  548.                u.more, tags );
  549.     END IntegerA;
  550.  
  551.   PROCEDURE KeyInteger * {"MuiSimple.KeyIntegerA"} ( contents{0} : LONGINT; maxlen{1} : LONGINT; controlchar{2}: CHAR; tags{9}.. : u.Tag ):m.Object;
  552.   PROCEDURE KeyIntegerA*( contents{0} : LONGINT; maxlen{1} : LONGINT; controlchar{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  553.     BEGIN (* SaveReg+ *)
  554.       RETURN Integer( contents, maxlen, m.aControlChar, controlchar, u.more, tags );
  555.     END KeyIntegerA;
  556.  
  557. (***************************************************************************
  558. **
  559. ** CheckMark-Object
  560. ** ----------------
  561. **
  562. ** The following procedure creates a checkmark gadget.
  563. **
  564. ***************************************************************************)
  565.  
  566.   PROCEDURE CheckMark * {"MuiSimple.CheckMarkA"}( checked{4} : BOOLEAN; tags{9}.. : u.Tag ):m.Object;
  567.   PROCEDURE CheckMarkA*( checked{4} : e.LONGBOOL; tags{9} : u.TagListPtr ):m.Object;
  568.    BEGIN (* SaveReg+ *)
  569.     RETURN ImageObject( m.aFrame, m.vFrameImageButton,
  570.             m.aInputMode, m.vInputModeToggle,
  571.             m.aImageSpec, m.iCheckMark,
  572.             m.aImageFreeVert, e.true,
  573.             m.aSelected, checked,
  574.             m.aBackground, m.iButtonBack,
  575.             m.aShowSelState, e.false,
  576.             u.more, tags );
  577.     END CheckMarkA;
  578.  
  579.   PROCEDURE KeyCheckMark *{"MuiSimple.KeyCheckMarkA"}( checked{4} : BOOLEAN; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  580.   PROCEDURE KeyCheckMarkA*( checked{4} : e.LONGBOOL; key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  581.    BEGIN (* SaveReg+ *)
  582.     RETURN CheckMark( y.VAL(BOOLEAN,SHORT(SHORT(checked))), m.aControlChar, key, u.more, tags );
  583.     END KeyCheckMarkA;
  584.  
  585.  
  586. (***************************************************************************
  587. **
  588. ** Button-Objects
  589. ** --------------
  590. **
  591. ** Note: Use small letters for KeyButtons, e.g.
  592. **       KeyButton("Cancel",'c')  and not  KeyButton("Cancel",'C') !!
  593. **
  594. ***************************************************************************)
  595.  
  596.   PROCEDURE Button* {"MuiSimple.ButtonA"} ( label{8} : ARRAY OF CHAR ): m.Object;
  597.   PROCEDURE ButtonA* (label{8} : y.ADDRESS ):m.Object;
  598.     BEGIN
  599.       RETURN m.MakeObject( m.oButton, label );
  600.     END ButtonA;
  601.         
  602.   PROCEDURE SimpleButton * {"MuiSimple.SimpleButtonA"} ( name{8} : ARRAY OF CHAR ):m.Object;
  603.   PROCEDURE SimpleButtonA * ( name{8} : e.LSTRPTR ):m.Object;
  604.     BEGIN (* SaveReg+ *)
  605.       RETURN m.MakeObject( m.oButton, name );
  606.     END SimpleButtonA;
  607.  
  608.  
  609. (***************************************************************************
  610. **
  611. ** Cycle-Object
  612. ** ------------
  613. **
  614. ***************************************************************************)
  615.  
  616.   PROCEDURE Cycle * {"MuiSimple.CycleA"} ( entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  617.   PROCEDURE CycleA * ( entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  618.     BEGIN (* SaveReg+ *)
  619.       RETURN CycleObject( m.aCycleEntries, entries, u.more, tags );
  620.     END CycleA;
  621.  
  622.   PROCEDURE KeyCycle * {"MuiSimple.KeyCycleA"} ( entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  623.   PROCEDURE KeyCycleA * ( entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  624.     BEGIN (* SaveReg+ *)
  625.       RETURN Cycle( entries, m.aControlChar, key, u.more, tags );
  626.     END KeyCycleA;
  627.  
  628. (***************************************************************************
  629. **
  630. ** Radio-Object
  631. ** ------------
  632. **
  633. ***************************************************************************)
  634.  
  635.   PROCEDURE Radio * {"MuiSimple.RadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; tags{9}.. : u.Tag ):m.Object;
  636.   PROCEDURE RadioA * ( name{8}: e.LSTRPTR; entries{10} : e.APTR; tags{9} : u.TagListPtr ):m.Object;
  637.     BEGIN (* SaveReg+ *)
  638.       RETURN RadioObject( m.aFrame, m.vFrameGroup,
  639.               m.aFrameTitle, name,
  640.               m.aRadioEntries, entries,
  641.               u.more, tags );
  642.     END RadioA;
  643.  
  644.   PROCEDURE KeyRadio * {"MuiSimple.KeyRadioA"} ( name{8} : ARRAY OF CHAR; entries{10} : e.APTR; key{4} : CHAR; tags{9}.. : u.Tag ):m.Object;
  645.   PROCEDURE KeyRadioA * ( name{8}: e.LSTRPTR; entries{10} : e.APTR; key{4} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  646.     BEGIN (* SaveReg+ *)
  647.       RETURN Radio( name^, entries, m.aControlChar, key, u.more, tags );
  648.     END KeyRadioA;
  649.  
  650. (***************************************************************************
  651. **
  652. ** Slider-Object
  653. ** -------------
  654. **
  655. ***************************************************************************)
  656.  
  657.   PROCEDURE Slider * {"MuiSimple.SliderA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  658.   PROCEDURE SliderA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  659.     BEGIN (* SaveReg+ *)
  660.       RETURN SliderObject( m.aSliderMin, min,
  661.                m.aSliderMax, max,
  662.                m.aSliderLevel, level,
  663.                u.more, tags );
  664.     END SliderA;
  665.  
  666.   PROCEDURE KeySlider * {"MuiSimple.KeySliderA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  667.   PROCEDURE KeySliderA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  668.     BEGIN (* SaveReg+ *)
  669.       RETURN Slider( min, max, level, m.aControlChar, key, u.more, tags );
  670.     END KeySliderA;
  671.  
  672.   PROCEDURE VSlider * {"MuiSimple.VSliderA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  673.   PROCEDURE VSliderA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  674.     BEGIN (* SaveReg+ *)
  675.       RETURN Slider( min, max, level, m.aGroupHoriz, e.false, u.more, tags );
  676.     END VSliderA;
  677.  
  678.   PROCEDURE KeyVSlider * {"MuiSimple.KeyVSliderA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  679.   PROCEDURE KeyVSliderA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  680.     BEGIN (* SaveReg+ *)
  681.       RETURN VSlider( min,  max, level, m.aControlChar, key, u.more, tags );
  682.     END KeyVSliderA;
  683.  
  684. (***************************************************************************
  685. **
  686. ** Scrollbar-Object
  687. ** -------------
  688. **
  689. ***************************************************************************)
  690.  
  691.   PROCEDURE Scrollbar * {"MuiSimple.ScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  692.   PROCEDURE ScrollbarA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  693.     BEGIN (* SaveReg+ *)
  694.       RETURN ScrollbarObject( m.aSliderMin, min,
  695.                   m.aSliderMax, max,
  696.                   m.aSliderLevel, level,
  697.                   m.aGroupHoriz, e.true,
  698.                   u.more, tags );
  699.     END ScrollbarA;
  700.  
  701.   PROCEDURE KeyScrollbar * {"MuiSimple.KeyScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  702.   PROCEDURE KeyScrollbarA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  703.     BEGIN (* SaveReg+ *)
  704.       RETURN Scrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  705.     END KeyScrollbarA;
  706.  
  707.   PROCEDURE VScrollbar * {"MuiSimple.VScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; tags{9}.. : u.Tag ):m.Object;
  708.   PROCEDURE VScrollbarA * ( min{0}, max{1}, level{2} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  709.     BEGIN (* SaveReg+ *)
  710.       RETURN ScrollbarObject( m.aSliderMin, min,
  711.                   m.aSliderMax, max,
  712.                   m.aSliderLevel, level,
  713.                   u.more, tags );
  714.     END VScrollbarA;
  715.  
  716.   PROCEDURE KeyVScrollbar * {"MuiSimple.KeyVScrollbarA"} ( min{0}, max{1}, level{2} : LONGINT; key{3} : CHAR; tags{9}.. : u.Tag ):m.Object;
  717.   PROCEDURE KeyVScrollbarA * ( min{0}, max{1}, level{2}, key{3} : LONGINT; tags{9} : u.TagListPtr ):m.Object;
  718.     BEGIN (* SaveReg+ *)
  719.       RETURN VScrollbar( min, max, level, m.aControlChar, key, u.more, tags );
  720.     END KeyVScrollbarA;
  721.  
  722. (***************************************************************************
  723. **
  724. ** Button to be used for popup objects
  725. **
  726. ***************************************************************************)
  727.  
  728.   PROCEDURE PopButton* {"MuiSimple.PopButtonA"} ( img{3} : LONGINT ):m.Object;
  729.   PROCEDURE PopButtonA*( img{3} : LONGINT ):m.Object;
  730.     BEGIN (* SaveReg+ *)
  731.       RETURN m.MakeObject( m.oPopButton, img );
  732.     END PopButtonA;
  733.  
  734. (***************************************************************************
  735. **
  736. ** Labeling Objects
  737. ** ----------------
  738. **
  739. ** Labeling objects, e.g. a group of string gadgets,
  740. **
  741. **   Small: |foo   |
  742. **  Normal: |bar   |
  743. **     Big: |foobar|
  744. **    Huge: |barfoo|
  745. **
  746. ** is done using a 2 column group:
  747. **
  748. ** ColGroup(2);
  749. **      Child; Label2( "Small:"  );
  750. **    Child; StringObject; end;
  751. **      Child; Label2( "Normal:" );
  752. **    Child; StringObject; end;
  753. **      Child; Label2( "Big:"    );
  754. **    Child; StringObject; end;
  755. **      Child; Label2( "Huge:"   );
  756. **    Child; StringObject; end;
  757. **    end;
  758. **
  759. ** Note that we have three versions of the label procedure, depending on
  760. ** the frame type of the right hand object:
  761. **
  762. ** Label1(): For use with standard frames (e.g. checkmarks).
  763. ** Label2(): For use with double high frames (e.g. string gadgets).
  764. ** Label() : For use with objects without a frame.
  765. **
  766. ** These procedures ensure that your label will look fine even if the
  767. ** user of your application configured some strange spacing values.
  768. ** If you want to use your own labeling, you'll have to pay attention
  769. ** on this topic yourself.
  770. **
  771. ***************************************************************************)
  772.  
  773.   PROCEDURE Label* {"MuiSimple.LabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  774.   PROCEDURE LabelA * ( label{8} : e.LSTRPTR ):m.Object;
  775.     BEGIN (* SaveReg+ *)
  776.       RETURN m.MakeObject( m.oLabel, label, 0 );
  777.     END LabelA;
  778.  
  779.   PROCEDURE Label1* {"MuiSimple.Label1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  780.   PROCEDURE Label1A * ( label{8} : e.LSTRPTR ):m.Object;
  781.     BEGIN (* SaveReg+ *)
  782.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame );
  783.     END Label1A;
  784.  
  785.   PROCEDURE Label2* {"MuiSimple.Label2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  786.   PROCEDURE Label2A * ( label{8} : e.LSTRPTR ):m.Object;
  787.     BEGIN (* SaveReg+ *)
  788.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame );
  789.     END Label2A;
  790.  
  791.   PROCEDURE LLabel* {"MuiSimple.LLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  792.   PROCEDURE LLabelA * ( label{8} : e.LSTRPTR ):m.Object;
  793.     BEGIN (* SaveReg+ *)
  794.       RETURN m.MakeObject( m.oLabel, label, m.oLabelLeftAligned );
  795.     END LLabelA;
  796.  
  797.   PROCEDURE LLabel1* {"MuiSimple.LLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  798.   PROCEDURE LLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
  799.     BEGIN (* SaveReg+ *)
  800.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+m.oLabelLeftAligned );
  801.     END LLabel1A;
  802.  
  803.   PROCEDURE LLabel2* {"MuiSimple.LLabel2A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  804.   PROCEDURE LLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
  805.     BEGIN (* SaveReg+ *)
  806.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned );
  807.     END LLabel2A;
  808.  
  809.   PROCEDURE CLabel* {"MuiSimple.CLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  810.   PROCEDURE CLabelA * ( label{8} : e.LSTRPTR ):m.Object;
  811.     BEGIN (* SaveReg+ *)
  812.       RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered );
  813.     END CLabelA;
  814.  
  815.   PROCEDURE CLabel1* {"MuiSimple.CLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  816.   PROCEDURE CLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
  817.     BEGIN (* SaveReg+ *)
  818.       RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+m.oLabelSingleFrame );
  819.     END CLabel1A;
  820.  
  821.   PROCEDURE CLabel2* {"MuiSimple.CLabel2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  822.   PROCEDURE CLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
  823.     BEGIN (* SaveReg+ *)
  824.       RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+m.oLabelDoubleFrame );
  825.     END CLabel2A;
  826.  
  827.   PROCEDURE KeyLabel*{"MuiSimple.KeyLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  828.   PROCEDURE KeyLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
  829.     BEGIN (* SaveReg+ *)
  830.       RETURN m.MakeObject( m.oLabel, label, 0+hichar );
  831.     END KeyLabelA;
  832.  
  833.   PROCEDURE KeyLabel1*{"MuiSimple.KeyLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  834.   PROCEDURE KeyLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  835.     BEGIN (* SaveReg+ *)
  836.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+hichar );
  837.     END KeyLabel1A;
  838.  
  839.   PROCEDURE KeyLabel2*{"MuiSimple.KeyLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  840.   PROCEDURE KeyLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  841.     BEGIN (* SaveReg+ *)
  842.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  843.     END KeyLabel2A;
  844.  
  845.   PROCEDURE KeyLLabel*{"MuiSimple.KeyLLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR):m.Object;
  846.   PROCEDURE KeyLLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  847.     BEGIN (* SaveReg+ *)
  848.       RETURN m.MakeObject( m.oLabel, label, 0+hichar );
  849.     END KeyLLabelA;
  850.  
  851.   PROCEDURE KeyLLabel1*{"MuiSimple.KeyLLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  852.   PROCEDURE KeyLLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  853.     BEGIN (* SaveReg+ *)
  854.       RETURN m.MakeObject( m.oLabel, label, m.oLabelSingleFrame+m.oLabelLeftAligned+hichar );
  855.     END KeyLLabel1A;
  856.  
  857.   PROCEDURE KeyLLabel2*{"MuiSimple.KeyLLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  858.   PROCEDURE KeyLLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  859.     BEGIN (* SaveReg+ *)
  860.       RETURN m.MakeObject( m.oLabel, label, m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  861.     END KeyLLabel2A;
  862.  
  863.   PROCEDURE KeyCLabel*{"MuiSimple.KeyCLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  864.   PROCEDURE KeyCLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
  865.     BEGIN (* SaveReg+ *)
  866.       RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+hichar );
  867.     END KeyCLabelA;
  868.  
  869.   PROCEDURE KeyCLabel1*{"MuiSimple.KeyCLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  870.   PROCEDURE KeyCLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  871.     BEGIN (* SaveReg+ *)
  872.       RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+m.oLabelSingleFrame+hichar );
  873.     END KeyCLabel1A;
  874.  
  875.   PROCEDURE KeyCLabel2*{"MuiSimple.KeyCLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  876.   PROCEDURE KeyCLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  877.     BEGIN (* SaveReg+ *)
  878.       RETURN m.MakeObject( m.oLabel, label, m.oLabelCentered+m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  879.     END KeyCLabel2A;
  880.  
  881.  
  882.   PROCEDURE FreeLabel* {"MuiSimple.FreeLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  883.   PROCEDURE FreeLabelA * ( label{8} : e.LSTRPTR ):m.Object;
  884.     BEGIN (* SaveReg+ *)
  885.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+0 );
  886.     END FreeLabelA;
  887.  
  888.   PROCEDURE FreeLabel1* {"MuiSimple.FreeLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  889.   PROCEDURE FreeLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
  890.     BEGIN (* SaveReg+ *)
  891.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelSingleFrame );
  892.     END FreeLabel1A;
  893.  
  894.   PROCEDURE FreeLabel2* {"MuiSimple.FreeLabel2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  895.   PROCEDURE FreeLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
  896.     BEGIN (* SaveReg+ *)
  897.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelDoubleFrame );
  898.     END FreeLabel2A;
  899.  
  900.   PROCEDURE FreeLLabel* {"MuiSimple.FreeLLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  901.   PROCEDURE FreeLLabelA * ( label{8} : e.LSTRPTR ):m.Object;
  902.     BEGIN (* SaveReg+ *)
  903.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelLeftAligned );
  904.     END FreeLLabelA;
  905.  
  906.   PROCEDURE FreeLLabel1* {"MuiSimple.FreeLLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  907.   PROCEDURE FreeLLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
  908.     BEGIN (* SaveReg+ *)
  909.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelSingleFrame+m.oLabelLeftAligned );
  910.     END FreeLLabel1A;
  911.  
  912.   PROCEDURE FreeLLabel2* {"MuiSimple.FreeLLabel2A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  913.   PROCEDURE FreeLLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
  914.     BEGIN (* SaveReg+ *)
  915.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelDoubleFrame+m.oLabelLeftAligned );
  916.     END FreeLLabel2A;
  917.  
  918.   PROCEDURE FreeCLabel* {"MuiSimple.FreeCLabelA"} ( label {8} : ARRAY OF CHAR ):m.Object;
  919.   PROCEDURE FreeCLabelA * ( label{8} : e.LSTRPTR ):m.Object;
  920.     BEGIN (* SaveReg+ *)
  921.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered );
  922.     END FreeCLabelA;
  923.  
  924.   PROCEDURE FreeCLabel1* {"MuiSimple.FreeCLabel1A"} ( label {8} : ARRAY OF CHAR ):m.Object;
  925.   PROCEDURE FreeCLabel1A * ( label{8} : e.LSTRPTR ):m.Object;
  926.     BEGIN (* SaveReg+ *)
  927.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+m.oLabelSingleFrame );
  928.     END FreeCLabel1A;
  929.  
  930.   PROCEDURE FreeCLabel2* {"MuiSimple.FreeCLabel2A"} ( label {8} : ARRAY OF CHAR):m.Object;
  931.   PROCEDURE FreeCLabel2A * ( label{8} : e.LSTRPTR ):m.Object;
  932.     BEGIN (* SaveReg+ *)
  933.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+m.oLabelDoubleFrame );
  934.     END FreeCLabel2A;
  935.  
  936.   PROCEDURE FreeKeyLabel*{"MuiSimple.FreeKeyLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  937.   PROCEDURE FreeKeyLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
  938.     BEGIN (* SaveReg+ *)
  939.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+0+hichar );
  940.     END FreeKeyLabelA;
  941.  
  942.   PROCEDURE FreeKeyLabel1*{"MuiSimple.FreeKeyLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  943.   PROCEDURE FreeKeyLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  944.     BEGIN (* SaveReg+ *)
  945.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelSingleFrame+hichar );
  946.     END FreeKeyLabel1A;
  947.  
  948.   PROCEDURE FreeKeyLabel2*{"MuiSimple.FreeKeyLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  949.   PROCEDURE FreeKeyLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  950.     BEGIN (* SaveReg+ *)
  951.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  952.     END FreeKeyLabel2A;
  953.  
  954.   PROCEDURE FreeKeyLLabel*{"MuiSimple.FreeKeyLLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR):m.Object;
  955.   PROCEDURE FreeKeyLLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  956.     BEGIN (* SaveReg+ *)
  957.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+0+hichar );
  958.     END FreeKeyLLabelA;
  959.  
  960.   PROCEDURE FreeKeyLLabel1*{"MuiSimple.FreeKeyLLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  961.   PROCEDURE FreeKeyLLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  962.     BEGIN (* SaveReg+ *)
  963.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelSingleFrame+m.oLabelLeftAligned+hichar );
  964.     END FreeKeyLLabel1A;
  965.  
  966.   PROCEDURE FreeKeyLLabel2*{"MuiSimple.FreeKeyLLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  967.   PROCEDURE FreeKeyLLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  968.     BEGIN (* SaveReg+ *)
  969.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  970.     END FreeKeyLLabel2A;
  971.  
  972.   PROCEDURE FreeKeyCLabel*{"MuiSimple.FreeKeyCLabelA"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  973.   PROCEDURE FreeKeyCLabelA * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT  ):m.Object;
  974.     BEGIN (* SaveReg+ *)
  975.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+hichar );
  976.     END FreeKeyCLabelA;
  977.  
  978.   PROCEDURE FreeKeyCLabel1*{"MuiSimple.FreeKeyCLabel1A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  979.   PROCEDURE FreeKeyCLabel1A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  980.     BEGIN (* SaveReg+ *)
  981.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+m.oLabelSingleFrame+hichar );
  982.     END FreeKeyCLabel1A;
  983.  
  984.   PROCEDURE FreeKeyCLabel2*{"MuiSimple.FreeKeyCLabel2A"} ( label{8} : ARRAY OF CHAR; hichar{3} : CHAR ):m.Object;
  985.   PROCEDURE FreeKeyCLabel2A * ( label{8} : e.LSTRPTR; hichar{3} : LONGINT ):m.Object;
  986.     BEGIN (* SaveReg+ *)
  987.       RETURN m.MakeObject( m.oLabel, label, m.oLabelFreeVert+m.oLabelCentered+m.oLabelDoubleFrame+m.oLabelLeftAligned+hichar );
  988.     END FreeKeyCLabel2A;
  989.  
  990.  
  991. (***************************************************************************
  992. **
  993. ** Controlling Objects
  994. ** -------------------
  995. **
  996. ** Set() and Get() are two short stubs for BOOPSI GetAttr() and SetAttrs()
  997. ** calls:
  998. **
  999. **
  1000. **    VAR x : e.LSTRPTR;
  1001. **
  1002. **    Set(obj,MUIA_String_Contents, y.ADR("foobar") );
  1003. **    Get(obj,MUIA_String_Contents, x);
  1004. **
  1005. **    Dos.PrintF( "gadget contains '%s'\n" , x );
  1006. **
  1007. ** NNset() sets an attribute without triggering a possible notification.
  1008. **
  1009. **
  1010. ***************************************************************************)
  1011.  
  1012.   PROCEDURE Set*( obj : m.Object; attr, value : e.APTR );
  1013.     BEGIN (* SaveReg+ *)
  1014.       IF I.SetAttrs( obj, attr, value, u.end ) = 0 THEN END
  1015.     END Set;
  1016.  
  1017.   PROCEDURE Get*( obj : m.Object; attr : LONGINT ; VAR store : ARRAY OF e.BYTE );
  1018.     BEGIN (* SaveReg+ *)
  1019.       IF I.GetAttr( attr, obj, store) = 0 THEN END
  1020.     END Get;
  1021.  
  1022.   PROCEDURE NNSet( obj : m.Object; attr, value : e.APTR );
  1023.     BEGIN (* SaveReg+ *)
  1024.       IF I.SetAttrs( obj, m.aNoNotify, e.LTRUE, attr, value, u.end ) = 0 THEN END
  1025.     END NNSet;
  1026.  
  1027.   PROCEDURE SetMutex * ( obj : m.Object; n : LONGINT );
  1028.     BEGIN (* SaveReg+ *)
  1029.       Set( obj, m.aRadioActive, n );
  1030.     END SetMutex;
  1031.  
  1032.   PROCEDURE SetCycle * ( obj : m.Object; n : LONGINT );
  1033.     BEGIN (* SaveReg+ *)
  1034.       Set( obj, m.aCycleActive, n );
  1035.     END SetCycle;
  1036.  
  1037.   PROCEDURE SetString * ( obj : m.Object; s : ARRAY OF CHAR );
  1038.     BEGIN (* SaveReg+ *)
  1039.       Set( obj, m.aStringContents, y.ADR( s ) );
  1040.     END SetString;
  1041.  
  1042.   PROCEDURE SetCheckmark * ( obj : m.Object; b : BOOLEAN );
  1043.     BEGIN (* SaveReg+ *)
  1044.       Set( obj, m.aSelected, y.VAL(SHORTINT,b) );
  1045.     END SetCheckmark;
  1046.  
  1047.   PROCEDURE SetSlider * ( obj : m.Object; l : LONGINT );
  1048.     BEGIN (* SaveReg+ *)
  1049.       Set( obj, m.aSliderLevel, l );
  1050.     END SetSlider;
  1051.  
  1052.   PROCEDURE MAKEID*( c1, c2, c3, c4 : CHAR):LONGINT;
  1053.     BEGIN (* SaveReg+ *)
  1054.       RETURN( y.LSH( ORD(c1), 24 )+
  1055.           y.LSH( ORD(c2), 16 )+
  1056.           y.LSH( ORD(c3),  8 )+
  1057.           ORD(c4) )
  1058.     END MAKEID;
  1059.  
  1060. BEGIN
  1061.   IF m.base.version < 8 THEN HALT( 100 ) END;
  1062. END MuiSimple.
  1063.  
  1064.  
  1065.